/**
 * 智能缓存管理器
 * 提供数据缓存、预加载、过期管理等功能
 */

class CacheManager {
  constructor() {
    this.cache = new Map();
    this.preloadQueue = new Map();
    this.maxCacheSize = 50; // 最大缓存条目数
    this.defaultTTL = 5 * 60 * 1000; // 默认5分钟过期
  }

  /**
   * 设置缓存
   * @param {string} key 缓存键
   * @param {any} data 缓存数据
   * @param {number} ttl 过期时间(毫秒)
   */
  set(key, data, ttl = this.defaultTTL) {
    // 清理过期缓存
    this.cleanExpired();
    
    // 如果缓存已满，删除最旧的条目
    if (this.cache.size >= this.maxCacheSize) {
      const oldestKey = this.cache.keys().next().value;
      this.cache.delete(oldestKey);
    }

    const cacheItem = {
      data,
      timestamp: Date.now(),
      ttl,
      accessCount: 0,
      lastAccess: Date.now()
    };

    this.cache.set(key, cacheItem);
    console.log(`[Cache] 设置缓存: ${key}`);
    if (key.includes('pet_list')) {
      console.log(`[Cache] 宠物列表缓存详情:`);
      console.log('- 数据类型:', typeof data);
      console.log('- 数据长度:', Array.isArray(data) ? data.length : 'N/A');
      console.log('- TTL:', ttl);
    }
  }

  /**
   * 获取缓存
   * @param {string} key 缓存键
   * @returns {any|null} 缓存数据或null
   */
  get(key) {
    const item = this.cache.get(key);
    
    if (!item) {
      return null;
    }

    // 检查是否过期
    if (Date.now() - item.timestamp > item.ttl) {
      this.cache.delete(key);
      console.log(`[Cache] 缓存过期: ${key}`);
      return null;
    }

    // 更新访问统计
    item.accessCount++;
    item.lastAccess = Date.now();
    
    console.log(`[Cache] 命中缓存: ${key}`);
    if (key.includes('pet_list')) {
      console.log(`[Cache] 宠物列表缓存命中详情:`);
      console.log('- 数据类型:', typeof item.data);
      console.log('- 数据长度:', Array.isArray(item.data) ? item.data.length : 'N/A');
      console.log('- 缓存时间:', new Date(item.timestamp).toLocaleString());
      console.log('- 访问次数:', item.accessCount);
    }
    return item.data;
  }

  /**
   * 检查缓存是否存在且未过期
   * @param {string} key 缓存键
   * @returns {boolean}
   */
  has(key) {
    const item = this.cache.get(key);
    if (!item) return false;
    
    return Date.now() - item.timestamp <= item.ttl;
  }

  /**
   * 删除缓存
   * @param {string} key 缓存键
   */
  delete(key) {
    this.cache.delete(key);
    console.log(`[Cache] 删除缓存: ${key}`);
  }

  /**
   * 清理过期缓存
   */
  cleanExpired() {
    const now = Date.now();
    for (const [key, item] of this.cache.entries()) {
      if (now - item.timestamp > item.ttl) {
        this.cache.delete(key);
        console.log(`[Cache] 清理过期缓存: ${key}`);
      }
    }
  }

  /**
   * 预加载数据
   * @param {string} key 缓存键
   * @param {Function} loader 数据加载函数
   * @param {number} ttl 过期时间
   */
  async preload(key, loader, ttl = this.defaultTTL) {
    // 如果已有缓存且未过期，跳过预加载
    if (this.has(key)) {
      console.log(`[Cache] 跳过预加载(已有缓存): ${key}`);
      return this.get(key);
    }

    // 如果正在预加载，等待结果
    if (this.preloadQueue.has(key)) {
      console.log(`[Cache] 等待预加载完成: ${key}`);
      return await this.preloadQueue.get(key);
    }

    // 开始预加载
    const promise = loader().then(data => {
      this.set(key, data, ttl);
      this.preloadQueue.delete(key);
      return data;
    }).catch(error => {
      this.preloadQueue.delete(key);
      throw error;
    });

    this.preloadQueue.set(key, promise);
    return promise;
  }

  /**
   * 批量预加载
   * @param {Array} tasks 预加载任务数组 [{key, loader, ttl}]
   */
  async preloadBatch(tasks) {
    const promises = tasks.map(task => 
      this.preload(task.key, task.loader, task.ttl)
    );
    
    try {
      const results = await Promise.allSettled(promises);
      console.log(`[Cache] 批量预加载完成: ${tasks.length} 个任务`);
      return results;
    } catch (error) {
      console.error('[Cache] 批量预加载失败:', error);
      return [];
    }
  }

  /**
   * 获取缓存统计信息
   */
  getStats() {
    const stats = {
      totalItems: this.cache.size,
      preloadingItems: this.preloadQueue.size,
      memoryUsage: this.cache.size * 0.1 // 粗略估算
    };

    // 计算访问频率最高的缓存
    const sortedByAccess = Array.from(this.cache.entries())
      .sort((a, b) => b[1].accessCount - a[1].accessCount)
      .slice(0, 5);

    stats.topAccessed = sortedByAccess.map(([key, item]) => ({
      key,
      accessCount: item.accessCount,
      lastAccess: item.lastAccess
    }));

    return stats;
  }

  /**
   * 清空所有缓存
   */
  clear() {
    this.cache.clear();
    this.preloadQueue.clear();
    console.log('[Cache] 清空所有缓存');
  }
}

// 创建全局缓存实例
const cacheManager = new CacheManager();

module.exports = cacheManager;
